using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("CollectionPageManager")]
	public class CollectionPageManager : MonoBehaviour
	{
		public enum ArrowClickType
		{
			DISABLED,
			ENABLED,
			SWITCH_MODE
		}

		public enum PageTransitionType
		{
			NONE,
			SINGLE_PAGE_RIGHT,
			SINGLE_PAGE_LEFT,
			MANY_PAGE_RIGHT,
			MANY_PAGE_LEFT
		}

		[Attribute38("CollectionPageManager.TransitionReadyCallbackData")]
		public class TransitionReadyCallbackData : MonoClass
		{
			public CollectionPageDisplay m_assembledPage => method_3<CollectionPageDisplay>("m_assembledPage");

			public CollectionPageDisplay m_otherPage => method_3<CollectionPageDisplay>("m_otherPage");

			public PageTransitionType m_transitionType => method_2<PageTransitionType>("m_transitionType");

			public object m_callbackData => method_3<object>("m_callbackData");

			public TransitionReadyCallbackData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TransitionReadyCallbackData(IntPtr address)
				: this(address, "TransitionReadyCallbackData")
			{
			}
		}

		public static List<TAG_CLASS> CLASS_TAB_ORDER => MonoClass.smethod_7<Class250<TAG_CLASS>>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "CLASS_TAB_ORDER")?.method_25();

		public GameObject m_classTabContainer => method_3<GameObject>("m_classTabContainer");

		public CollectionClassTab m_classTabPrefab => method_3<CollectionClassTab>("m_classTabPrefab");

		public GameObject m_pageRightArrowBone => method_3<GameObject>("m_pageRightArrowBone");

		public GameObject m_pageLeftArrowBone => method_3<GameObject>("m_pageLeftArrowBone");

		public PegUIElement m_pageRightClickableRegion => method_3<PegUIElement>("m_pageRightClickableRegion");

		public PegUIElement m_pageLeftClickableRegion => method_3<PegUIElement>("m_pageLeftClickableRegion");

		public PegUIElement m_pageDraggableRegion => method_3<PegUIElement>("m_pageDraggableRegion");

		public CollectionPageDisplay m_pageDisplayPrefab => method_3<CollectionPageDisplay>("m_pageDisplayPrefab");

		public PageTurn m_pageTurn => method_3<PageTurn>("m_pageTurn");

		public float m_turnLeftPageSwapTiming => method_2<float>("m_turnLeftPageSwapTiming");

		public float m_spaceBetweenTabs => method_2<float>("m_spaceBetweenTabs");

		public CollectionClassTab m_heroSkinsTab => method_3<CollectionClassTab>("m_heroSkinsTab");

		public CollectionClassTab m_cardBacksTab => method_3<CollectionClassTab>("m_cardBacksTab");

		public ClassFilterHeaderButton m_classFilterHeader => method_3<ClassFilterHeaderButton>("m_classFilterHeader");

		public CollectionClassTab m_deckTemplateTab => method_3<CollectionClassTab>("m_deckTemplateTab");

		public int m_transitionPageId => method_2<int>("m_transitionPageId");

		public string m_deckTemplatePickerPrefab => method_4("m_deckTemplatePickerPrefab");

		public static List<CollectionManagerDisplay.ViewMode> TAG_ORDERING => MonoClass.smethod_7<Class250<CollectionManagerDisplay.ViewMode>>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "TAG_ORDERING")?.method_25();

		public static float SELECT_TAB_ANIM_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "SELECT_TAB_ANIM_TIME");

		public static Vector3 CURRENT_PAGE_LOCAL_POS => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "CURRENT_PAGE_LOCAL_POS");

		public static Vector3 NEXT_PAGE_LOCAL_POS => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "NEXT_PAGE_LOCAL_POS");

		public static Vector3 CLASS_TAB_LOCAL_EULERS => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "CLASS_TAB_LOCAL_EULERS");

		public static float HIDDEN_TAB_LOCAL_Z_POS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "HIDDEN_TAB_LOCAL_Z_POS");

		public static float ARROW_SCALE_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "ARROW_SCALE_TIME");

		public static string ANIMATE_TABS_COROUTINE_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "ANIMATE_TABS_COROUTINE_NAME");

		public static string SELECT_TAB_COROUTINE_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "SELECT_TAB_COROUTINE_NAME");

		public static string SHOW_ARROWS_COROUTINE_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "SHOW_ARROWS_COROUTINE_NAME");

		public static int NUM_PAGE_FLIPS_BEFORE_STOP_SHOWING_ARROWS => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "NUM_PAGE_FLIPS_BEFORE_STOP_SHOWING_ARROWS");

		public static int NUM_PAGE_FLIPS_BEFORE_SET_FILTER_TUTORIAL => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "NUM_PAGE_FLIPS_BEFORE_SET_FILTER_TUTORIAL");

		public static int MASS_DISENCHANT_PAGE_NUM => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionPageManager", "MASS_DISENCHANT_PAGE_NUM");

		public CollectionPageDisplay m_pageA => method_3<CollectionPageDisplay>("m_pageA");

		public CollectionPageDisplay m_pageB => method_3<CollectionPageDisplay>("m_pageB");

		public bool m_currentPageIsPageA => method_2<bool>("m_currentPageIsPageA");

		public int m_currentPageNum => method_2<int>("m_currentPageNum");

		public int m_lastPageNum => method_2<int>("m_lastPageNum");

		public List<CollectionClassTab> m_classTabs => method_3<Class271<CollectionClassTab>>("m_classTabs")?.method_25();

		public List<CollectionClassTab> m_allTabs => method_3<Class271<CollectionClassTab>>("m_allTabs")?.method_25();

		public CollectionClassTab m_currentClassTab => method_3<CollectionClassTab>("m_currentClassTab");

		public bool m_tabsAreAnimating => method_2<bool>("m_tabsAreAnimating");

		public CollectibleCard m_lastCardAnchor => method_3<CollectibleCard>("m_lastCardAnchor");

		public GameObject m_pageRightArrow => method_3<GameObject>("m_pageRightArrow");

		public GameObject m_pageLeftArrow => method_3<GameObject>("m_pageLeftArrow");

		public bool m_rightArrowShown => method_2<bool>("m_rightArrowShown");

		public bool m_leftArrowShown => method_2<bool>("m_leftArrowShown");

		public bool m_delayShowingArrows => method_2<bool>("m_delayShowingArrows");

		public float m_deselectedClassTabHalfWidth => method_2<float>("m_deselectedClassTabHalfWidth");

		public bool m_initializedTabPositions => method_2<bool>("m_initializedTabPositions");

		public bool m_fullyLoaded => method_2<bool>("m_fullyLoaded");

		public MassDisenchant m_massDisenchant => method_3<MassDisenchant>("m_massDisenchant");

		public DeckTemplatePicker m_deckTemplatePicker => method_3<DeckTemplatePicker>("m_deckTemplatePicker");

		public CollectibleCardClassFilter m_cardsCollection => method_3<CollectibleCardClassFilter>("m_cardsCollection");

		public CollectibleCardHeroesFilter m_heroesCollection => method_3<CollectibleCardHeroesFilter>("m_heroesCollection");

		public bool m_wasTouchModeEnabled => method_2<bool>("m_wasTouchModeEnabled");

		public bool m_useLastPage => method_2<bool>("m_useLastPage");

		public bool m_skipNextPageTurn => method_2<bool>("m_skipNextPageTurn");

		public bool m_pagesCurrentlyTurning => method_2<bool>("m_pagesCurrentlyTurning");

		public Vector3 m_heroSkinsTabPos => method_2<Vector3>("m_heroSkinsTabPos");

		public Vector3 m_cardBacksTabPos => method_2<Vector3>("m_cardBacksTabPos");

		public bool m_hideNonDeckTemplateTabs => method_2<bool>("m_hideNonDeckTemplateTabs");

		public int m_numPageFlipsThisSession => method_2<int>("m_numPageFlipsThisSession");

		public CollectionPageManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public CollectionPageManager(IntPtr address)
			: this(address, "CollectionPageManager")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public bool HideNonDeckTemplateTabs(bool hide, bool updateTabs)
		{
			return method_11<bool>("HideNonDeckTemplateTabs", new object[2] { hide, updateTabs });
		}

		public bool IsNonDeckTemplateTabsHidden()
		{
			return method_11<bool>("IsNonDeckTemplateTabsHidden", Array.Empty<object>());
		}

		public void OnCollectionLoaded()
		{
			method_8("OnCollectionLoaded");
		}

		public void OnBookOpening()
		{
			method_8("OnBookOpening");
		}

		public bool JumpToPageWithCard(string cardID, TAG_PREMIUM premium)
		{
			return method_10<bool>("JumpToPageWithCard", new Class276.Enum20[2]
			{
				Class276.Enum20.String,
				Class276.Enum20.ValueType
			}, new object[2] { cardID, premium });
		}

		public void RemoveAllClassFilters()
		{
			method_9("RemoveAllClassFilters", new Class276.Enum20[0]);
		}

		public void FilterByManaCost(int cost)
		{
			method_9("FilterByManaCost", new Class276.Enum20[1] { Class276.Enum20.I4 }, cost);
		}

		public bool CardSetFilterIncludesWild()
		{
			return method_11<bool>("CardSetFilterIncludesWild", Array.Empty<object>());
		}

		public void ChangeSearchTextFilter(string newSearchText, bool updateVisuals)
		{
			method_9("ChangeSearchTextFilter", new Class276.Enum20[2]
			{
				Class276.Enum20.String,
				Class276.Enum20.Boolean
			}, newSearchText, updateVisuals);
		}

		public void RemoveSearchTextFilter()
		{
			method_9("RemoveSearchTextFilter", new Class276.Enum20[0]);
		}

		public void ShowOnlyCardsIOwn()
		{
			method_9("ShowOnlyCardsIOwn", new Class276.Enum20[0]);
		}

		public void ShowCardsNotOwned(bool includePremiums)
		{
			method_9("ShowCardsNotOwned", new Class276.Enum20[1] { Class276.Enum20.Boolean }, includePremiums);
		}

		public void ShowPremiumCardsOnly()
		{
			method_9("ShowPremiumCardsOnly", new Class276.Enum20[0]);
		}

		public void ShowCraftableCardsOnly(bool showCraftableCardsOnly)
		{
			method_9("ShowCraftableCardsOnly", new Class276.Enum20[1] { Class276.Enum20.Boolean }, showCraftableCardsOnly);
		}

		public void ShowCraftingModeCards(bool showCraftableCardsOnly, bool showGolden, bool updatePage, bool toggleChanged)
		{
			method_9("ShowCraftingModeCards", new Class276.Enum20[4]
			{
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, showCraftableCardsOnly, showGolden, updatePage, toggleChanged);
		}

		public void UpdateCurrentPageCardLocks(bool playSound)
		{
			method_8("UpdateCurrentPageCardLocks", playSound);
		}

		public void UpdateClassTabNewCardCounts()
		{
			method_8("UpdateClassTabNewCardCounts");
		}

		public int GetNumNewCardsForClass(TAG_CLASS tagClass)
		{
			return method_11<int>("GetNumNewCardsForClass", new object[1] { tagClass });
		}

		public void NotifyOfCollectionChanged()
		{
			method_8("NotifyOfCollectionChanged");
		}

		public void OnDoneEditingDeck()
		{
			method_8("OnDoneEditingDeck");
		}

		public void UpdateCraftingModeButtonDustBottleVisibility()
		{
			method_8("UpdateCraftingModeButtonDustBottleVisibility");
		}

		public int GetMassDisenchantAmount()
		{
			return method_11<int>("GetMassDisenchantAmount", Array.Empty<object>());
		}

		public void RefreshCurrentPageContents()
		{
			method_9("RefreshCurrentPageContents", new Class276.Enum20[0]);
		}

		public void RefreshCurrentPageContents(PageTransitionType transition)
		{
			method_9("RefreshCurrentPageContents", new Class276.Enum20[1] { Class276.Enum20.ValueType }, transition);
		}

		public CollectionCardVisual GetCardVisual(string cardID, TAG_PREMIUM premium)
		{
			return method_14<CollectionCardVisual>("GetCardVisual", new object[2] { cardID, premium });
		}

		public bool IsFullyLoaded()
		{
			return method_11<bool>("IsFullyLoaded", Array.Empty<object>());
		}

		public void LoadMassDisenchantScreen()
		{
			method_8("LoadMassDisenchantScreen");
		}

		public void ShowMassDisenchant()
		{
			method_8("ShowMassDisenchant");
		}

		public void HideMassDisenchant()
		{
			method_8("HideMassDisenchant");
		}

		public bool IsShowingMassDisenchant()
		{
			return method_11<bool>("IsShowingMassDisenchant", Array.Empty<object>());
		}

		public bool ArePagesTurning()
		{
			return method_11<bool>("ArePagesTurning", Array.Empty<object>());
		}

		public int GetNumPagesForClass(TAG_CLASS classTag)
		{
			return method_11<int>("GetNumPagesForClass", new object[1] { classTag });
		}

		public bool ShouldShowTab(CollectionClassTab tab)
		{
			return method_11<bool>("ShouldShowTab", new object[1] { tab });
		}

		public void SetUpClassTabs()
		{
			method_8("SetUpClassTabs");
		}

		public void PositionClassTabs(bool animate)
		{
			method_8("PositionClassTabs", animate);
		}

		public void PositionFixedTab(bool showTab, CollectionClassTab tab, Vector3 originalPos, bool animate)
		{
			method_8("PositionFixedTab", showTab, tab, originalPos, animate);
		}

		public void DeselectCurrentClassTab()
		{
			method_8("DeselectCurrentClassTab");
		}

		public void SetDeckRuleset(DeckRuleset deckRuleset, bool refresh)
		{
			method_8("SetDeckRuleset", deckRuleset, refresh);
		}

		public void UpdateVisibleTabs()
		{
			method_8("UpdateVisibleTabs");
		}

		public void OnTabOver(UIEvent e)
		{
			method_8("OnTabOver", e);
		}

		public void OnTabOut(UIEvent e)
		{
			method_8("OnTabOut", e);
		}

		public void OnTabOver_Touch(UIEvent e)
		{
			method_8("OnTabOver_Touch", e);
		}

		public void OnTabOut_Touch(UIEvent e)
		{
			method_8("OnTabOut_Touch", e);
		}

		public bool CanUserTurnPages()
		{
			return method_11<bool>("CanUserTurnPages", Array.Empty<object>());
		}

		public void OnClassTabPressed(UIEvent e)
		{
			method_8("OnClassTabPressed", e);
		}

		public void OnDeckTemplateTabPressed(UIEvent e)
		{
			method_8("OnDeckTemplateTabPressed", e);
		}

		public void OnHeroSkinsTabPressed(UIEvent e)
		{
			method_8("OnHeroSkinsTabPressed", e);
		}

		public void OnCardBacksTabPressed(UIEvent e)
		{
			method_8("OnCardBacksTabPressed", e);
		}

		public void UpdateMassDisenchant()
		{
			method_8("UpdateMassDisenchant");
		}

		public void JumpToCollectionClassPage(TAG_CLASS pageClass)
		{
			method_9("JumpToCollectionClassPage", new Class276.Enum20[1] { Class276.Enum20.ValueType }, pageClass);
		}

		public void SwapCurrentAndAltPages()
		{
			method_8("SwapCurrentAndAltPages");
		}

		public CollectionPageDisplay GetCurrentPage()
		{
			return method_14<CollectionPageDisplay>("GetCurrentPage", Array.Empty<object>());
		}

		public CollectionPageDisplay GetAlternatePage()
		{
			return method_14<CollectionPageDisplay>("GetAlternatePage", Array.Empty<object>());
		}

		public void AssembleEmptyPageUI(CollectionPageDisplay page, bool displayNoMatchesText)
		{
			method_8("AssembleEmptyPageUI", page, displayNoMatchesText);
		}

		public bool AssembleBasePage(TransitionReadyCallbackData transitionReadyCallbackData, bool emptyPage, bool wildPage)
		{
			return method_11<bool>("AssembleBasePage", new object[3] { transitionReadyCallbackData, emptyPage, wildPage });
		}

		public void AssembleDeckTemplatePage(TransitionReadyCallbackData transitionReadyCallbackData)
		{
			method_8("AssembleDeckTemplatePage", transitionReadyCallbackData);
		}

		public DeckTemplatePicker GetDeckTemplatePicker()
		{
			return method_14<DeckTemplatePicker>("GetDeckTemplatePicker", Array.Empty<object>());
		}

		public void UpdateDeckTemplate(DeckTemplatePicker deckTemplatePicker)
		{
			method_8("UpdateDeckTemplate", deckTemplatePicker);
		}

		public void AssembleCardBackPage(TransitionReadyCallbackData transitionReadyCallbackData)
		{
			method_8("AssembleCardBackPage", transitionReadyCallbackData);
		}

		public void PositionCurrentPage(CollectionPageDisplay page)
		{
			method_8("PositionCurrentPage", page);
		}

		public void PositionNextPage(CollectionPageDisplay page)
		{
			method_8("PositionNextPage", page);
		}

		public void TransitionPage(object callbackData)
		{
			method_8("TransitionPage", callbackData);
		}

		public void OnPageTurnComplete(object callbackData, int operationId)
		{
			method_8("OnPageTurnComplete", callbackData, operationId);
		}

		public void UpdateFilteredHeroes()
		{
			method_8("UpdateFilteredHeroes");
		}

		public void UpdateFilteredCards()
		{
			method_8("UpdateFilteredCards");
		}

		public void ActivateArrows(bool leftArrow, bool rightArrow)
		{
			method_8("ActivateArrows", leftArrow, rightArrow);
		}

		public void OnPageLeftPressed(UIEvent e)
		{
			method_8("OnPageLeftPressed", e);
		}

		public void OnPageFlip()
		{
			method_8("OnPageFlip");
		}

		public void ShowSetFilterTutorialIfNeeded()
		{
			method_8("ShowSetFilterTutorialIfNeeded");
		}

		public void OnPageRightPressed(UIEvent e)
		{
			method_8("OnPageRightPressed", e);
		}

		public void LoadPagingArrows()
		{
			method_8("LoadPagingArrows");
		}

		public void OnPagingArrowLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnPagingArrowLoaded", assetRef, go, callbackData);
		}

		public void ShowArrow(GameObject arrow, bool show, bool isRightArrow)
		{
			method_8("ShowArrow", arrow, show, isRightArrow);
		}

		public void OnCollectionManagerViewModeChanged(CollectionManagerDisplay.ViewMode prevMode, CollectionManagerDisplay.ViewMode mode, CollectionManagerDisplay.ViewModeData userdata, bool triggerResponse)
		{
			method_8("OnCollectionManagerViewModeChanged", prevMode, mode, userdata, triggerResponse);
		}

		public void OnFavoriteHeroChanged(TAG_CLASS heroClass, NetCache.CardDefinition favoriteHero, object userData)
		{
			method_8("OnFavoriteHeroChanged", heroClass, favoriteHero, userData);
		}

		public void OnDefaultCardbackChanged(int newDefaultCardBackID, object userData)
		{
			method_8("OnDefaultCardbackChanged", newDefaultCardBackID, userData);
		}

		public int GetLastPageInCurrentMode()
		{
			return method_11<int>("GetLastPageInCurrentMode", Array.Empty<object>());
		}
	}
}
